#include <iostream>
#include <cassert>
#include <string>
#include <vector>
#include <typeinfo>
#include <unistd.h>

class Any
{
    private:
        class Holder {
            public:
                virtual ~Holder(){}
                virtual const std::type_info& type() = 0; //获取子类存储的数据类型
                virtual Holder* clone() = 0; //通过子类在构建一个新的通用类型。 //??? 这个干什么的
        };
        template<class T>
        class placeholder : public Holder
        {
            public:
                placeholder(const T& val)
                    :_val(val)
                    {}
                virtual ~placeholder(){}
                //返回数据类型
                virtual const std::type_info& type() { return typeid(_val);} 
                //clone处一个新的对象返回回去
                virtual Holder* clone() { return new placeholder<T>(_val); } 
                T& GetVal() {return _val;}
            private:
                T _val; 
        };
        Holder* _con; 
    public:
        //无参数构造
        Any() :_con(nullptr)
            {} 
        ~Any()
        {
            if (_con)
            {
                delete _con;
                _con = nullptr;
            }
        }            
        //可以构造任意类型            
        template<class T> 
        Any(const T& val) 
            :_con(new Any::placeholder<T>(val))
            {} 

        Any(const Any&other)
            :_con(other._con->clone())
            {} //通过其他的any构造

        //获取子类存储的数据
        template<class T>
        T* get()
        {
            assert(typeid(T) == _con->type()); //如果你想要得到的值和我保存的值不一样直接断言
            return &(((placeholder<T>*)_con)->GetVal());
        } 
        //为了方便进行复制，我们添加一个swap函数
        Any& swap(Any&other){
            std::swap(_con,other._con);
            return *this;
        }
        //因为有无参的构造，所以需要让任意类型可以赋值
        template<class T> 
        Any& operator=(const T& val){
            return Any(val).swap(*this); //生成一个临时的Any对象，交换之后生命周期结束，然后自动释放掉。
        } 

        //通过其他的any赋值，默认的，如果不写的话，上面的模版不管用，会调用默认的赋值拷贝构造函数 (浅拷贝)
        Any& operator=(const Any&other)
        {
            return Any(other).swap(*this); 
        }  
};

class Test 
{
    public:
        Test (){std::cout << "构造" << std::endl;}
        ~Test (){std::cout << "析构" << std::endl;}
        //参数不能传值传递
        Test(const Test& t) {std::cout << "拷贝" << std::endl;}
};

int main()
{

    Any a;
    {
        Test t;
        a = t;
    }
    
    while(1) sleep(1);
    // a = 10;
    // char arr[]  = "12345678";
    // Any a = 100;
    // Any b = std::string(arr);

    // std::cout << *(a.get<int>()) << std::endl;
    // std::cout << *(b.get<std::string>()) << std::endl;
    // Any c(b);
    // a = c;
    // std::cout << *(c.get<std::string>()) << std::endl;
    // std::cout << *(a.get<std::string>()) << std::endl;
    // std::vector<int> a1(10,0);

    // a = a1;
    // for (auto& x : *(a.get<std::vector<int>>())){
    //     std::cout << x << std::endl;
    // }
    return 0;
}